home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / viewers / polyview / hdf-ucd.lha / HDF-UCD / util.c < prev    next >
C/C++ Source or Header  |  1992-03-03  |  12KB  |  369 lines
  1. #include  "basetype.h"
  2. #include "util.h"
  3.  
  4. /*can be defined as a macro later */
  5. /*******************************************************************************
  6. * function:            int EVEN(v)
  7. * description:         returns true if v is even, false otherwise
  8. * parameters:          v
  9. * return value:        1 or 0 depending on v even or odd
  10. * modified parameters: none
  11. *******************************************************************************/
  12.  
  13.  
  14. int EVEN(v)
  15. {
  16.   if ((v % 2) == 0) return(1); return(0);
  17. }
  18.  
  19.  
  20. /*******************************************************************************
  21. * procedure:           void handleerror(errnum)
  22. * description:         prints a message associated with errnum.
  23. * parameters:          errnum
  24. * return value:        none
  25. * modified parameters: none
  26. *******************************************************************************/
  27.  
  28. void handleerror(errnum)
  29. int errnum;
  30. {
  31.   switch (errnum) {
  32.     case 100: printf("illegal face type \n"); break;
  33.     case 200: printf("memory allocation failed \n"); break;
  34.     case 300: printf("Finite Element type not yet supported \n"); break;
  35.     case 400: printf("Connectivity data file format not OK \n"); break;
  36.     case 500: printf("Error opening data file \n"); break;
  37.     case 600: printf("\nFailed to Match Faces(version #)\n");
  38.               printf("Check Sequence Set Calls\n"); break;
  39.   }
  40.   exit(0);
  41. }
  42.  
  43. /*******************************************************************************
  44. * procedure:           char *MemAlloc(size)
  45. * description:         allocates size bytes and returns a pointer to memory
  46. * parameters:          size
  47. * return value:        Str (pointer to memory)
  48. * modified parameters: none
  49. *******************************************************************************/
  50.  
  51. char *MemAlloc(size)
  52. int size;
  53. {
  54.   char *Str;
  55.     if ( (Str = (char *) malloc(size)) == NULL) handleerror(200);
  56.     return(Str);
  57. }
  58.  
  59. /*******************************************************************************
  60. * procedure:           void MemRelease(Str)
  61. * description:         releases memory pointed to by Str
  62. * parameters:          Str
  63. * return value:        none
  64. * modified parameters: none
  65. *******************************************************************************/
  66.  
  67. void MemRelease(Str)
  68. char *Str;
  69. {
  70.   free(Str);
  71. }
  72.  
  73. /*******************************************************************************
  74. * procedure:           void inithashtabs()
  75. * description:         initializes the hash tables used for 
  76. *                      processing faces of cells in mesh.
  77. * parameters:          none
  78. * return value:        none
  79. * modified parameters: quadhashtab, trihashtab
  80. *******************************************************************************/
  81.  
  82. void inithashtabs(maxvertices)
  83. int maxvertices;
  84. {
  85.   int i;
  86.     trihashtab = (triface **)MemAlloc(sizeof(triface *)*maxvertices);
  87.     quadhashtab =(quadface **) MemAlloc(sizeof(quadface *)*maxvertices);
  88.     for (i = 0; i < maxvertices; i++)
  89.       {quadhashtab[i] = NULL; trihashtab[i] = NULL;}
  90. }
  91.  
  92. /*******************************************************************************
  93. * procedure:           void freehashtabs()
  94. * description:         frees memory allocated for hash tables.
  95. * parameters:          none
  96. * return value:        none
  97. * modified parameters: quadhashtab, trihashtab
  98. *******************************************************************************/
  99.  
  100. void freehashtabs(maxvertices)
  101. int maxvertices;
  102. {
  103.   int i;
  104.   quadface *qf, *tqf; triface *tf, *ttf;
  105.     for (i = 0; i < maxvertices; i++) {
  106.       qf = tqf = quadhashtab[i];
  107.       if (qf != NULL) {
  108.         while (qf->Next !=  NULL) {
  109.           tqf = qf; qf = qf->Next;
  110.           MemRelease(tqf);
  111.         } MemRelease (qf);
  112.       }
  113.       tf = ttf = trihashtab[i];
  114.       if (tf != NULL) {
  115.         while (tf->Next !=  NULL) {
  116.           ttf = tf; tf = tf->Next;
  117.           MemRelease(ttf);
  118.         } MemRelease (tf);
  119.       }
  120.     }
  121.     MemRelease(quadhashtab); MemRelease(trihashtab);
  122. }
  123.  
  124. /*******************************************************************************
  125. * function:            int scrambleij(i, j)
  126. * description:         packs i and j into one word and returns that value.
  127. * parameters:          i, j
  128. *                      _____ 
  129. * return value:        |i|j|
  130. *                      ----- 
  131. * modified parameters: none
  132. *******************************************************************************/
  133.  
  134. int scrambleij (i, j)
  135. int i, j;
  136. {
  137.   int n = 0;
  138.     n = n | abs(i); n = (n << 16) | abs(j); return(n);
  139.     /* 16 == half of word size = 32
  140.        16 bits for i, 16 bits for j, packed into one word */
  141. }
  142.  
  143. /*******************************************************************************
  144. * procedure:           void unscrambleij(n, i, j)
  145. * description:         splits n into i and j.
  146. * parameters:          n, i, j
  147. * return value:        none
  148. * modified parameters: i, j
  149. *******************************************************************************/
  150.  
  151. void unscrambleij (n, i, j)
  152. int n, *i, *j;
  153. {
  154.   n = abs(n);
  155.   *j = n & umask1; *i = (n >> 16); 
  156.   /* 16 == half of word size = 32
  157.     j = lower 16 bits, i = higher 16 bits */
  158. }
  159.  
  160. /*******************************************************************************
  161. * function:            int scramblefv(f, v)
  162. * description:         packs f and v into one word and returns that value.
  163. * parameters:          f, v
  164. *                      _____________
  165. * return value:        |f        |v|
  166. *                      -------------
  167. * modified parameters: none
  168. *******************************************************************************/
  169.  
  170. int scramblefv (f, v)
  171. int f, v;
  172. {
  173.   int n = 0;
  174.     n = n | abs(f); n = (n << 3) | abs(v); return(n);
  175.     /* 29 bits for f, 3 bits for v */
  176. }
  177.  
  178. /*******************************************************************************
  179. * procedure:           void unscramblefv(n, f, v)
  180. * description:         splits n into f and v.
  181. * parameters:          n, f, v
  182. * return value:        none
  183. * modified parameters: f, v
  184. *******************************************************************************/
  185.  
  186. void unscramblefv (n, f, v)
  187. int n, *f, *v;
  188. {
  189.   n = abs(n);
  190.   *v = n & umask2; *f = (n >> 3);
  191.     /* 29 bits for f, 3 bits for v */
  192. }
  193.  
  194. /*******************************************************************************
  195. * function:            int findmin(fv, num)
  196. * description:         finds the minimum of the numbers in array fv.
  197. *                      size of fv given by num.
  198. * parameters:          fv, num
  199. * return value:        minimum value
  200. * modified parameters: none
  201. *******************************************************************************/
  202.  
  203. int findmin(fv, num)
  204. int *fv, num;
  205. /* num is either 4 quadfaces, or 3 trifaces */
  206. {
  207.   int min, i; 
  208.     min = fv[0];
  209.     for (i = 1; i < num; i++) if (fv[i] < min) min = fv[i];
  210.     return (min);
  211. } 
  212.       
  213. /*******************************************************************************
  214. * procedure:           void qstoreface(facevertices, index)
  215. * description:         stores face given by facevertices, index  in hash table.
  216. * parameters:          facevertices, index
  217. * return value:        none
  218. * modified parameters: quadhashtab(in util.h)
  219. *******************************************************************************/
  220.  
  221. void qstoreface(facevertices, index)
  222. int  *facevertices, index;
  223. {
  224.   quadface *f; int min;
  225.     min = findmin(facevertices, 4); /* 4= # vertices of quad face */
  226.     f = (quadface *) MemAlloc(SizeOfquadface);
  227.     f->i = facevertices[0]; f->j = facevertices[1];
  228.     f->k = facevertices[2]; f->l = facevertices[3];
  229.     f->faceindex = index; f->Next = quadhashtab[min];
  230.     quadhashtab[min] = f;
  231. }
  232.  
  233. /*******************************************************************************
  234. * procedure:           void tstoreface(facevertices, index)
  235. * description:         stores face given by facevertices in hash table.
  236. * parameters:          facevertices, index
  237. * return value:        none
  238. * modified parameters: trihashtab(in util.h)
  239. *******************************************************************************/
  240.  
  241. void tstoreface(facevertices, index)
  242. int  *facevertices, index;
  243. {
  244.   triface *f; int min;
  245.     min = findmin(facevertices, 3); /* 3=#of vetices of tri face */
  246.     f = (triface *) MemAlloc(SizeOftriface);
  247.     f->i = facevertices[0]; f->j = facevertices[1];
  248.     f->k = facevertices[2];
  249.     f->faceindex = index; f->Next = trihashtab[min];
  250.     trihashtab[min] = f;
  251. }
  252.  
  253. /*******************************************************************************
  254. * function:            BOOLEAN qinlist (v, f)
  255. * description:         checks if vertex v is one of the vertices of face f.
  256. * parameters:          v, f
  257. * return value:        True or False
  258. * modified parameters: none
  259. *******************************************************************************/
  260.  
  261. BOOLEAN  qinlist (v, f)
  262. int  v;
  263. quadface *f;
  264. {
  265.   if ((v == f->i) || (v == f->j) || (v == f->k) || (v == f->l)) return(True);
  266.   return(False);
  267. }
  268.  
  269. /*******************************************************************************
  270. * function:            BOOLEAN tinlist (v, f)
  271. * description:         checks if vertex v is one of the vertices of face f.
  272. * parameters:          v, f
  273. * return value:        True or False
  274. * modified parameters: none
  275. *******************************************************************************/
  276.  
  277. BOOLEAN  tinlist (v, f)
  278. int  v;
  279. triface *f;
  280. {
  281.   if ((v == f->i) || (v == f->j) || (v == f->k)) return(True);
  282.   return(False);
  283. }
  284.  
  285. /*******************************************************************************
  286. * function:            BOOLEAN qequal(facevertices, findex, f)
  287. * description:         checks if facevertices and f refer to the same face.
  288. * parameters:          facevertices, findex, f
  289. * return value:        True or False
  290. * modified parameters: findex
  291. *******************************************************************************/
  292.  
  293. BOOLEAN qequal(facevertices, findex, f)
  294. int  *facevertices, *findex;
  295. quadface *f;
  296. {
  297.   int i;
  298.     for (i = 0; i < 4; i++) {
  299.       if (!(qinlist(facevertices[i], f))) return(False);
  300.     }
  301.     *findex = f->faceindex;
  302.     return (True); /* all the 4 vertices are there */
  303. }
  304.   
  305. /*******************************************************************************
  306. * function:            BOOLEAN tequal(facevertices, findex, f)
  307. * description:         checks if facevertices and f refer to the same face.
  308. * parameters:          facevertices, findex, f
  309. * return value:        True or False
  310. * modified parameters: findex
  311. *******************************************************************************/
  312.  
  313. BOOLEAN tequal(facevertices, findex, f)
  314. int  *facevertices, *findex;
  315. triface *f;
  316. {
  317.   int i;
  318.     for (i = 0; i < 3; i++) {
  319.       if (!(tinlist(facevertices[i], f))) return(False);
  320.     }
  321.     *findex = f->faceindex;
  322.     return (True); /* all the 4 vertices are there */
  323. }
  324.  
  325. /*******************************************************************************
  326. * function:            BOOLEAN  qsearchface(facevertices, findex)
  327. * description:         searches for the face given by face 
  328. *                      vertices in the hashtable.
  329. * parameters:          facevertices, findex
  330. * return value:        True or False
  331. * modified parameters: findex
  332. *******************************************************************************/
  333.  
  334. BOOLEAN  qsearchface(facevertices, findex)
  335. int  *facevertices, *findex;
  336. {
  337.   int min; quadface *f;
  338.     min = findmin(facevertices, 4);
  339.     f = quadhashtab[min];
  340.     while (f != NULL) {
  341.       if (qequal (facevertices, findex, f)) return (True); /* face is there */
  342.       f = f->Next;
  343.     } 
  344.     return(False); /* face is not there */
  345. }
  346.  
  347. /*******************************************************************************
  348. * function:            BOOLEAN  tsearchface(facevertices, findex)
  349. * description:         searches for the face given by face 
  350.                        vertices in the hashtable.
  351. * parameters:          facevertices, findex
  352. * return value:        True or False
  353. * modified parameters: findex
  354. *******************************************************************************/
  355.  
  356. BOOLEAN  tsearchface(facevertices, findex)
  357. int  *facevertices, *findex;
  358. {
  359.   int min; triface *f;
  360.     min = findmin(facevertices, 3);
  361.     f = trihashtab[min];
  362.     while (f != NULL) {
  363.       if (tequal (facevertices, findex, f)) return (True); /* face is there */
  364.       f = f->Next;
  365.     } 
  366.     return(False); /* face is not there */
  367. }
  368.  
  369.